const router = require('koa-router')()
const crypto = require('crypto')
const jwt = require('jsonwebtoken')
const bcrypt = require('bcryptjs')

router.prefix('/api/user')

// 用户注册接口（不进行密码加密）
router.post('/register', async (ctx) => {
  const { username, password, nickname } = ctx.request.body

  // 参数校验
  if (!username?.trim() || !password?.trim()) {
    ctx.status = 400
    ctx.body = { code: 400, message: '用户名和密码不能为空' }
    return
  }

  try {
    // 检查用户名是否存在（最终修复版）
    try {
      console.log('正在检查用户名是否存在:', username.trim())
      const queryResult = await ctx.db.query(
        'SELECT COUNT(*) as count FROM users WHERE username = ?',
        [username.trim()]
      )
      
      // 统一处理查询结果
      const getCountFromResult = (result) => {
        try {
          // 尝试解析各种可能的返回格式
          const res = JSON.parse(JSON.stringify(result))
          
          // 格式1: [[{count: X}]]
          if (Array.isArray(res) && Array.isArray(res[0]) && res[0][0]?.count !== undefined) {
            return res[0][0].count
          }
          // 格式2: [{count: X}]
          if (Array.isArray(res) && res[0]?.count !== undefined) {
            return res[0].count
          }
          // 格式3: {count: X}
          if (res?.count !== undefined) {
            return res.count
          }
          // 格式4: 原始数字
          if (typeof res === 'number') {
            return res
          }
          return 0
        } catch (e) {
          console.error('解析查询结果出错:', e)
          return 0
        }
      }

      const count = getCountFromResult(queryResult)
      console.log('用户名检查结果 - count:', count)
      
      if (count > 0) {
        ctx.status = 409
        ctx.body = { code: 409, message: '用户名已存在' }
        return
      }
      
      // 继续执行注册逻辑...
    } catch (err) {
      console.error('检查用户名时出错:', err)
      ctx.status = 500
      ctx.body = { code: 500, message: '服务器内部错误' }
      return
    }

    // 密码加密
    const salt = await bcrypt.genSalt(10)
    const hashedPassword = await bcrypt.hash(password.trim(), salt)
    
    // 创建用户（修改结果处理方式）
    const insertResult = await ctx.db.query(
      `INSERT INTO users 
       (username, password, nickname, status)
       VALUES (?, ?, ?, 1)`,
      [username.trim(), hashedPassword, nickname || username.trim()]
    )
    console.log('插入结果:', JSON.stringify(insertResult))

    // 获取插入ID（兼容多种返回格式）
    let insertId
    if (Array.isArray(insertResult) && insertResult[0]?.insertId) {
      insertId = insertResult[0].insertId
    } else if (insertResult?.insertId) {
      insertId = insertResult.insertId
    } else if (Array.isArray(insertResult) && Array.isArray(insertResult[0]) && insertResult[0][0]?.insertId) {
      insertId = insertResult[0][0].insertId
    } else {
      console.error('无法解析插入ID:', insertResult)
      throw new Error('无法获取用户ID')
    }

    // 返回成功响应
    ctx.status = 200
    ctx.body = {
      code: 200,
      message: '注册成功',
      data: {
        userId: insertId
      }
    }

  } catch (err) {
    console.error('注册错误:', err)
    ctx.status = 500
    ctx.body = { code: 500, message: '注册失败，请稍后再试' }
  }
})

// 用户登录接口（明文密码验证）
router.post('/login', async (ctx) => {
  const { username, password } = ctx.request.body

  // 参数校验
  if (!username?.trim() || !password?.trim()) {
    ctx.status = 400
    ctx.body = { code: 400, message: '用户名和密码不能为空' }
    return
  }

  try {
    // 查询用户
    const rows = await ctx.db.query(
      'SELECT * FROM users WHERE username = ? LIMIT 1',
      [username.trim()]
    )

    // 用户不存在
    if (!rows.length) {
      ctx.status = 200
      ctx.body = { code: 401, message: '用户名或密码错误' }
      return
    }

    const user = rows[0]
    
    // 验证密码（兼容明文和bcrypt加密密码）
    let isPasswordValid = false
    
    // 先检查是否是明文密码（非bcrypt格式）
    if (!user.password.startsWith('$2b$') && !user.password.startsWith('$2a$') && !user.password.startsWith('$2y$')) {
      // 明文密码直接比较
      isPasswordValid = (password.trim() === user.password)
    } else {
      // bcrypt加密密码验证
      isPasswordValid = await bcrypt.compare(password.trim(), user.password)
    }
    
    if (!isPasswordValid) {
      ctx.status = 200
      ctx.body = { code: 401, message: '用户名或密码错误' }
      return
    }

    // 状态检查
    if (user.status !== 1) {
      ctx.status = 200
      ctx.body = { code: 403, message: '账号不可用' }
      return
    }

    // 生成Token
    const token = jwt.sign(
      { userId: user.user_id, username: user.username },
      process.env.JWT_SECRET || 'default-secret-key',
      { expiresIn: '24h' }
    )

    // 成功响应
    ctx.status = 200
    ctx.body = {
      code: 200,
      message: '登录成功',
      data: {
        userInfo: {
          userId: user.user_id,
          username: user.username,
          nickname: user.nickname || '',
          avatar: user.avatar || ''
        },
        token: token
      }
    }

  } catch (err) {
    console.error('登录错误:', err)
    ctx.status = 500
    ctx.body = { code: 500, message: '登录服务异常' }
  }
})

// 用户详情接口
router.get('/detail', async (ctx) => {
  try {
    // 从JWT token中获取用户信息
    const authHeader = ctx.request.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      ctx.status = 401;
      ctx.body = { code: 401, message: '未授权访问' };
      return;
    }
    
    const token = authHeader.substring(7); // 移除 "Bearer " 前缀
    
    let decoded;
    try {
      decoded = jwt.verify(token, process.env.JWT_SECRET || 'default-secret-key');
    } catch (err) {
      ctx.status = 401;
      ctx.body = { code: 401, message: 'Token无效' };
      return;
    }
    
    // 根据用户ID获取用户详情
    const rows = await ctx.db.query(
      'SELECT user_id, username, nickname, avatar FROM users WHERE user_id = ? LIMIT 1',
      [decoded.userId]
    );
    
    if (!rows.length) {
      ctx.status = 404;
      ctx.body = { code: 404, message: '用户不存在' };
      return;
    }
    
    const user = rows[0];
    
    ctx.status = 200;
    ctx.body = {
      code: 200,
      message: '获取用户信息成功',
      data: {
        userInfo: {
          userId: user.user_id,
          username: user.username,
          nickname: user.nickname || user.username,
          avatarUrl: user.avatar || '',
          level: 1
        }
      }
    };
  } catch (err) {
    console.error('获取用户详情错误:', err);
    ctx.status = 500;
    ctx.body = { code: 500, message: '获取用户信息失败' };
  }
});

module.exports = router